package io.sk.common.utils;

import io.sk.common.base.BaseResult;
import io.sk.common.base.Constants;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 数据验证、操作自定义工具
 *
 * @author xubinren
 * @version 1.0
 * @date 2018/5/8 18:23
 */
public class CheckDataUtils {

    /**
     * 根据添加信息返回的数据条数判断，添加是否成功
     *
     * @param addNum 添加信息返回的数据条数
     * @return boolean
     */
    public static boolean checkAddNum(Integer addNum) {
        if (null != addNum && addNum > Constants.INT_ZERO) {
            return true;
        }
        return false;
    }

    /**
     * 根据修改信息返回的数据条数判断，修改是否成功
     *
     * @param updateNum 修改信息返回的数据条数
     * @return boolean
     */
    public static boolean checkUpdateNum(Integer updateNum) {
        if (null != updateNum && updateNum < Constants.INT_TWO) {
            return true;
        }
        return false;
    }

    /**
     * 根据删除信息返回的数据条数判断，修改是否成功
     *
     * @param delNum 修改信息返回的数据条数
     * @return boolean
     */
    public static boolean checkDelNum(Integer delNum) {
        if (null != delNum && delNum > Constants.INT_ZERO) {
            return true;
        }
        return false;
    }

    /**
     * 验证列表是否存在数据
     *
     * @param list 列表
     * @return boolean
     */
    public static boolean isNotEmptyList(List list) {
        if (null != list && list.size() > Constants.INT_ZERO) {
            for (int i = Constants.INT_ZERO; i < list.size(); i++) {
                if (null != list.get(i)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 验证给的所有字符串是否有为空或空格
     *
     * @param anyString 不定个数字符串
     * @return boolean
     */
    public static boolean isAnyEmptyString(String... anyString) {
        for (String middleStr : anyString) {
            if (StringUtils.isEmpty(middleStr)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 验证给的所有字符串是否没有为空或空格
     *
     * @param anyString 不定个数字符串
     * @return boolean
     */
    public static boolean isNotAnyEmptyString(String... anyString) {
        for (String middleStr : anyString) {
            if (StringUtils.isEmpty(middleStr)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 将日期转为字符串
     *
     * @param conversionDate 待转换的日期
     * @param timeFormat     需要转换成的格式，null或""为yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static String dateToString(Date conversionDate, String timeFormat) {

        try {
            //待转换日期验证
            if (null == conversionDate) {
                return null;
            }

            //转化格式验证
            if (StringUtils.isEmpty(timeFormat)) {
                timeFormat = Constants.DATE_FORMAT2;
            } else {
                timeFormat = timeFormat.trim();
            }
            SimpleDateFormat formatter = new SimpleDateFormat(timeFormat);
            return formatter.format(conversionDate);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将字符串转为日期
     *
     * @param conversionDateString 待转换的日期
     * @param timeFormat           需要转换成的格式，null或""为yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static Date stringToDate(String conversionDateString, String timeFormat) {

        try {
            //待转换日期验证
            if (StringUtils.isEmpty(conversionDateString)) {
                return null;
            }

            //转化格式验证
            if (StringUtils.isEmpty(timeFormat)) {
                timeFormat = Constants.DATE_FORMAT2;
            }
            SimpleDateFormat formatter = new SimpleDateFormat(timeFormat);
            return formatter.parse(conversionDateString);
        } catch (Exception e) {
            System.out.println("stringToDate转换失败");
            return null;
        }
    }

    /**
     * 比较两个日期 ：请自行确定两日期值正确
     * 前者大于后者（当前时间离前者更近），返回1
     * 前者等于后者，返回0
     * 前者小于后者，返回-1
     * 异常，返回-2
     *
     * @param compareOne 日期1
     * @param compareTwo 日期2
     * @return int
     */
    public static int dateCompare(Date compareOne, Date compareTwo) {
        try {
            long compareOneLong = compareOne.getTime();
            long compareTwoLong = compareTwo.getTime();
            if (compareOneLong > compareTwoLong) {
                return Constants.INT_ONE;
            }
            if (compareOneLong == compareTwoLong) {
                return Constants.INT_ZERO;
            }
            if (compareOneLong < compareTwoLong) {
                return Constants.INT_NEGATIVE_ONE;
            }
            return Constants.INT_TWO;
        } catch (Exception e) {
            System.out.println("两日期无法比较");
            return Constants.INT_NEGATIVE_TWO;
        }
    }

    /**
     * 将日期（只要年月日）转为日期时间（时间按照：日期 + 00:00:00）
     *
     * @param conversionDate 待转换的日期
     * @return Date
     */
    public static Date dateToDate(Date conversionDate) {

        try {
            //待转换日期验证
            if (null == conversionDate) {
                return null;
            }
            //将日期转为yyyy-MM-dd格式字符串
            SimpleDateFormat formatter = new SimpleDateFormat(Constants.DATE_FORMAT1);
            String middleDate = formatter.format(conversionDate);

            return stringToDate(middleDate + Constants.DATE_ZERO, null);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将日期转为日期时间
     *
     * @param conversionDate 待转换的日期
     * @param spliceEnd      待转换日期转为字符串后，在末尾拼接上字符串
     * @param sourceFormat   待转换日期格式：默认为yyyy-MM-dd
     * @param aimsFormat     转换后的日期格式：默认为yyyy-MM-dd HH:mm:ss
     * @return Date
     */
    public static Date dateToDate(Date conversionDate, String spliceEnd, String sourceFormat, String aimsFormat) {

        try {
            //待转换日期验证
            if (null == conversionDate) {
                return null;
            }
            if (StringUtils.isEmpty(sourceFormat)) {
                sourceFormat = Constants.DATE_FORMAT1;
            }
            if (StringUtils.isEmpty(aimsFormat)) {
                sourceFormat = Constants.DATE_FORMAT2;
            }
            //将日期转为yyyy-MM-dd格式字符串
            SimpleDateFormat formatter = new SimpleDateFormat(sourceFormat);
            String middleDate = formatter.format(conversionDate);
            middleDate += spliceEnd;

            formatter = new SimpleDateFormat(aimsFormat);

            return formatter.parse(middleDate);
        } catch (Exception e) {
            System.out.println("dateToDate转换失败");
            return null;
        }
    }

    /**
     * 去除字符串两边的空格,没有则返回null
     *
     * @param dataStr 待操作字符串
     * @return String
     */
    public static String stringTrim(String dataStr) {
        if (StringUtils.isNotEmpty(dataStr)) {
            return dataStr.trim();
        }
        return null;
    }

    /**
     * 去除字符串两边的空格,没有则返回""
     *
     * @param dataStr 待操作字符串
     * @return String
     */
    public static String stringTrimBlank(String dataStr) {
        if (StringUtils.isNotEmpty(dataStr)) {
            return dataStr.trim();
        }
        return "";
    }

    /**
     * 返回BaseResult格式
     *
     * @return BaseResult
     */
    public static BaseResult sendResult200() {
        return new BaseResult(Constants.RESPONSE_CODE_200, Constants.RESPONSE_MESSAGE_200);
    }

    /**
     * 返回BaseResult格式
     *
     * @return BaseResult
     */
    public static BaseResult sendResult200(Object data) {
        return new BaseResult(Constants.RESPONSE_CODE_200, Constants.RESPONSE_MESSAGE_200, data);
    }

    /**
     * 返回BaseResult格式:参数错误
     *
     * @return BaseResult
     */
    public static BaseResult sendResult400() {
        return new BaseResult(Constants.RESPONSE_CODE_400, Constants.RESPONSE_MESSAGE_400);
    }

    /**
     * 返回BaseResult格式:参数错误
     *
     * @param message 提示信息
     * @return BaseResult
     */
    public static BaseResult sendResult400(String message) {
        return new BaseResult(Constants.RESPONSE_CODE_400, message);
    }

    /**
     * 返回BaseResult格式：数据保存失败
     *
     * @return BaseResult
     */
    public static BaseResult sendResult605() {
        return new BaseResult(Constants.RESPONSE_CODE_605, Constants.RESPONSE_MESSAGE_605);
    }

    /**
     * 返回BaseResult格式：数据保存失败
     *
     * @param message 提示信息
     * @return BaseResult
     */
    public static BaseResult sendResult605(String message) {
        return new BaseResult(Constants.RESPONSE_CODE_605, message);
    }

    /**
     * 返回BaseResult格式：数据更新失败
     *
     * @return BaseResult
     */
    public static BaseResult sendResult606() {
        return new BaseResult(Constants.RESPONSE_CODE_606, Constants.RESPONSE_MESSAGE_606);
    }

    /**
     * 返回BaseResult格式：数据更新失败
     *
     * @param message 提示信息
     * @return BaseResult
     */
    public static BaseResult sendResult606(String message) {
        return new BaseResult(Constants.RESPONSE_CODE_606, message);
    }

    /**
     * 返回BaseResult格式：操作的记录不存在
     *
     * @return BaseResult
     */
    public static BaseResult sendResult602() {
        return new BaseResult(Constants.RESPONSE_CODE_602, Constants.RESPONSE_MESSAGE_602);
    }

    /**
     * 返回BaseResult格式：操作的记录不存在
     *
     * @param message 提示信息
     * @return BaseResult
     */
    public static BaseResult sendResult602(String message) {
        return new BaseResult(Constants.RESPONSE_CODE_602, message);
    }

    /**
     * 返回BaseResult格式：数据库记录已存在
     *
     * @return BaseResult
     */
    public static BaseResult sendResult601() {
        return new BaseResult(Constants.RESPONSE_CODE_601, Constants.RESPONSE_MESSAGE_601);
    }

    /**
     * 返回BaseResult格式：数据库记录已存在
     *
     * @param message 提示信息
     * @return BaseResult
     */
    public static BaseResult sendResult601(String message) {
        return new BaseResult(Constants.RESPONSE_CODE_601, message);
    }


    /**
     * 验证Integer是否大于0
     *
     * @param middleInt 验证数据
     * @return boolean
     */
    public static boolean integerGtZero(Integer middleInt) {
        if (null == middleInt || middleInt < 1) {
            return false;
        }
        return true;
    }

    /**
     * 验证Integer是否大于0
     *
     * @param middleInt 验证数据
     * @return boolean
     */
    public static boolean intGtZero(int middleInt) {
        if (middleInt < 1) {
            return false;
        }
        return true;
    }

    /**
     * 删除数组中的空格和null,并删除数值中左右两边的空格
     *
     * @param middleArray 验证数据
     * @return String[]
     */
    public static String[] arrayTrim(String[] middleArray) {
        if (null == middleArray) {
            return null;
        }

        String middleStr = "";
        int j = 0;
        for (int i = 0; i < middleArray.length; i++) {
            if (StringUtils.isNotEmpty(middleArray[i]) && !"null".equals(middleArray[i].trim())) {
                middleStr += "," + middleArray[i].trim();
            }
        }
        if (StringUtils.isNotEmpty(middleStr)) {
            middleStr = middleStr.substring(1);
            return middleStr.split(",");
        }

        return null;
    }

    /**
     * 获取数组的第一个有效数据
     *
     * @param middleArray 验证数据
     * @return String[]
     */
    public static String arrayOne(String[] middleArray) {
        if (null == middleArray) {
            return null;
        }

        for (int i = 0; i < middleArray.length; i++) {
            if (StringUtils.isNotEmpty(middleArray[i])) {
                return middleArray[i];
            }
        }

        return null;
    }

    /**
     * 复制列表
     *
     * @param sourceList  源列表
     * @param targetList  目标列表
     * @param targetClass 目标列表对应的
     * @return List
     */
    public static List copyList(List sourceList, List targetList, Class targetClass) {
        try {
            if (null == sourceList || sourceList.size() < 0) {
                return null;
            }
            if (null == targetList) {
                targetList = new ArrayList(sourceList.size());
            }

            Object target;
            for (int i = 0; i < sourceList.size(); i++) {
                if (null == sourceList.get(i)) {
                    continue;
                }
                target = targetClass.newInstance();
                BeanUtils.copyProperties(sourceList.get(i), target);
                targetList.add(target);
            }

            return targetList;
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return null;
        }
    }

    /**
     * 遍历Map中的数据
     */
    public static void soutMap(Map<String, Object> map) {
        //遍历map中的键
        for (String key : map.keySet()) {
            System.out.println("Key = " + key);
        }
        //遍历map中的值
        for (Object value : map.values()) {
            System.out.println("Value = " + value);
        }
    }

    /**
     * 判断路径filePath下的 文件/文件夹 是否存在，不存在创建，并返回File
     *
     * @param filePath:文件路径
     * @param bl：最底层是否是文件而非文件夹，默认为true
     * @return note:格式不可改变分隔用“/”
     * eg:checkFile("E:/root/20161009/icitem012.dbf",null,)
     */
    public static File getFile(String filePath, boolean bl) {
        try {
            File file = null;
            if (null != filePath && !"".equals(filePath.trim())) {
                if (!bl) {//文件夹
                    file = getFolderCreateFolder(filePath);
                } else {//文件
                    file = getFileCreateFile(filePath);
                }
            }
            return file;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断路径filePath下的 文件/文件夹 是否存在，不存在创建，并返回File
     *
     * @param filePath:文件路径
     * @return note:格式不可改变分隔用“/”
     * eg:checkFile("E:/root/20161009/icitem012.dbf",null,)
     */
    public static File getFile(String filePath) {
        try {
            File file = null;
            if (null != filePath && !"".equals(filePath.trim())) {
                file = getFileCreateFile(filePath);
            }
            return file;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断文件夹是否存在，只有存在时返回true
     *
     * @return
     */
    public static boolean checkFolder(String filePath) {
        try {
            File file = new File(filePath);
            if (file.exists()) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断文件夹是否存在，只有存在时返回true;不存在时创建文件夹
     *
     * @return
     */
    public static boolean checkFolderCreateFolder(String filePath) {
        try {
            if (StringUtils.isEmpty(filePath)) {
                return false;
            }

            File file = new File(filePath);
            if (!file.exists()) {
                file.mkdirs();
                return false;
            } else {
                return true;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断文件夹是否存在，存在返回File ，不存在则创建File并返回
     *
     * @return
     */
    public static File getFolderCreateFolder(String filePath) {
        try {
            if (StringUtils.isEmpty(filePath)) {
                return null;
            }

            File file = new File(filePath);
            if (!file.exists()) {
                file.mkdirs();
            }
            return file;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断文件是否存在，只有存在时返回true
     *
     * @return
     */
    public static boolean checkFile(String filePath) {
        try {
            if (StringUtils.isEmpty(filePath)) {
                return false;
            }

            File file = new File(filePath);
            if (file.exists()) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断文件是否存在，只有存在时返回true;不存在时创建文件夹
     *
     * @return
     */
    public static boolean checkFileCreateFile(String filePath) {
        try {
            if (StringUtils.isEmpty(filePath)) {
                return false;
            }

            String[] strArry = filePath.trim().split("/");
            String fileName = strArry[strArry.length - 1];
            String foldName = filePath.trim().replaceAll(fileName, "");

            File file = new File(foldName);
            if (!file.exists()) {
                file.mkdirs();
            }

            file = new File(foldName, fileName);
            if (!file.exists()) {
                file.createNewFile();
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断文件是否存在，存在时返回File,不存在时创建并返回File;不存在时创建文件夹
     *
     * @return File
     */
    public static File getFileCreateFile(String filePath) {
        try {
            try {
                if (StringUtils.isEmpty(filePath)) {
                    return null;
                }

                String[] strArry = filePath.trim().split("/");
                String fileName = strArry[strArry.length - 1];
                String foldName = filePath.trim().replaceAll(fileName, "");

                File file = new File(foldName);
                if (!file.exists()) {
                    file.mkdirs();
                }

                file = new File(foldName, fileName);
                if (!file.exists()) {
                    file.createNewFile();
                }
                return file;
            } catch (Exception e) {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断路径filePath下的 文件、文件夹 是否存在
     *
     * @return boolean
     */
    public static boolean checkFilePath(String filePath) {
        try {
            if (StringUtils.isEmpty(filePath)) {
                return false;
            }
            File file = new File(filePath.trim());
            if (!file.exists()) {
                return true;
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 文件上传
     *
     * @return BaseResult
     */
    public static BaseResult setFile(CommonsMultipartFile file, String filePath) {
        try {
            if (StringUtils.isEmpty(filePath) || null == file) {
                return sendResult400();
            }
            File newFile = getFile(filePath, false);

            //通过CommonsMultipartFile的方法直接写文件
            if (null == newFile) {
                return sendResult400();
            }
            file.transferTo(newFile);

            return sendResult200(file);
        } catch (Exception e) {
            e.getMessage();
            return sendResult400();
        }
    }


    public static void main(String[] args) {

        String middleStr = ",sdfsdf,,,sdf,null,sdfsdf,,";
        String[] str = arrayTrim(middleStr.split(","));
        System.out.println(str.length);
    }


}
